package chaoyue.study.extend;

import java.util.Arrays;

/**
 * 继承破坏封装
 * 父类可被重写的方法中不要去调用其他可以被子类重写的方法
 */
public class ExtendBreakEncapsulation {
    public static void main(String[] args) {
        Child c = new Child();
        // 调用子类的addAll方法，此时对象的引用
        c.addAll(new int[]{1, 2, 3});
        System.out.println(c.getSum()); // 输出12 但正确的应该是6

    }

    private static class Base {
        private static final int MAX_NUM = 1000;
        private int[] arr = new int[MAX_NUM];
        private int count;

        public void add(int number) {
            if (count < MAX_NUM) {
                arr[count++] = number;
            }
        }

        /**
         *  父类的方法中调用了可被子类重写的方法
         *  则可能因为向下转型导致逻辑错误
         *  子类变的需要关心父类的具体实现，所以封装被打破
         */
        public void addAll(int[] numbers) {
            for (int num : numbers) {
                add(num);
            }
        }
    }

    private static class Child extends Base {
        private long sum;

        @Override
        public void add(int number) {
            super.add(number);
            sum += number;
        }

        /**
         * 子类addAll方法调用时，会先通过super关键字调用父类方法
         * 但是父类的addAll方法中调用了add方法，但此时因为是子类的引用，所以会动态绑定调用子类的方法
         * 所以相当于sum被调用了两次，导致逻辑错误
         */
        @Override
        public void addAll(int[] numbers) {
            super.addAll(numbers);
            sum += Arrays.stream(numbers).sum();
        }

        public long getSum() {
            return sum;
        }
    }
}

